package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsTargetTimingTaskDispatchService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetTimingTaskDispatch;
import com.wicket.okrapp.base.service.dto.req.QueryTimerTaskPlanListReq;
import com.wicket.okrapp.base.service.MOmsTargetObjectiveService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjective;
import com.wicket.okrapp.base.service.dto.req.QueryTargetObjDetailReq;
import com.wicket.okrapp.base.service.dto.req.QueryTimerTaskPlanDetailReq;
import java.util.ArrayList;

import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.OffStateService;
import com.wicket.okrapp.biz.service.TargetContentService;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.biz.service.nb.NbResetCheckItemState;
import com.wicket.okrapp.base.service.MOmsBizAppStatusCheckItemService;
import com.wicket.okrapp.dal.po.mbg.OmsBizAppStatusCheckItem;
import com.wicket.okrapp.base.service.dto.req.QueryBizAppCheckItemStatListReq;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.base.service.MOmsAssistCheckPanelUpdateService;
import com.wicket.okrapp.dal.po.mbg.OmsAssistCheckPanelUpdate;
import com.wicket.okrapp.base.service.dto.req.QueryCheckItemPanelListReq;
import com.wicket.okrcalc.integration.dto.CalculateSubtractionOfTwoNumServiceComRespDto;
import com.wicket.okrcalc.integration.dto.CalculateSubtractionOfTwoNumServiceComReqDto;
import com.wicket.okrcalc.integration.FwCalcCalculationRulesClient;
import com.wicket.okrapp.base.service.MOmsAssistNodeStatusService;
import com.wicket.okrapp.dal.po.mbg.OmsAssistNodeStatus;
import com.wicket.okrapp.base.service.dto.req.QueryAssistNodeStatusListReq;
import com.wicket.okrapp.biz.service.ExecuteProgressService;
import com.wicket.okrapp.biz.service.ProgressPublicTechnicaCapacityService;
import com.wicket.okrapp.base.service.MOmsTargetCategoryService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCategory;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCatListReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryBizAppCheckItemStatReq;
import com.wicket.okrapp.base.service.dto.req.QueryTargetObjListReq;
import com.wicket.okrapp.biz.service.IndexSystemService;
import com.wicket.okrapp.base.service.dto.req.ImplementAssistNodeStatusByCodeOrderReq;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.dto.req.ImplementContentMatchTargetCycleCodeOrderReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTargetObjListReq;
import com.wicket.okrapp.base.service.MOmsTaskService;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class ResetCheckItemStateServiceImpl
  implements com.wicket.okrapp.biz.service.ResetCheckItemStateService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
@Resource
  private MOmsTargetObjectiveService mOmsTargetObjectiveService;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private OffStateService offStateService;
@Resource
  private TargetContentService targetContentService;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private NbResetCheckItemState nbResetCheckItemState;
@Resource
  private MOmsBizAppStatusCheckItemService mOmsBizAppStatusCheckItemService;
@Resource
  private MOmsAssistCheckPanelUpdateService mOmsAssistCheckPanelUpdateService;
@Resource
  private FwCalcCalculationRulesClient fwCalcCalculationRulesClient;
@Resource
  private MOmsAssistNodeStatusService mOmsAssistNodeStatusService;
@Resource
  private ExecuteProgressService executeProgressService;
@Resource
  private ProgressPublicTechnicaCapacityService progressPublicTechnicaCapacityService;
@Resource
  private MOmsTargetCategoryService mOmsTargetCategoryService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private MOmsTaskService mOmsTaskService;
/**
   * D3执行循环补偿改目标重置下级检查项状态(公共)[6628]
   * gen by moon at 5/19/2023, 6:45:09 AM
   */
  @Trace(operationName = "D3执行循环补偿改目标重置下级检查项状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopOffsetUpdateTargetResetCheckItemStateComRespDto implementLoopOffsetUpdateTargetResetCheckItemStateCom(ImplementLoopOffsetUpdateTargetResetCheckItemStateComReqDto reqDto){
    
      
      //virtualUsage 3-2-09查重置下级检查项状态定时任务调度列表  41494
      List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch =new ArrayList<>();
    QueryTimerTaskPlanListReq queryTimerTaskPlanListReq=new QueryTimerTaskPlanListReq();
  queryTimerTaskPlanListReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:933581_1_41494
queryTimerTaskPlanListReq.setDispatchActionTypeCode("DISPATCH_DOWNWARD_UPDATE_TARGET_SET_CHECK_ITEM_ETC_STATE");//sourceId:933582_1_41494
queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:933585_1_41494
queryTimerTaskPlanListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:933586_1_41494
if(reqDto!=null){
      queryTimerTaskPlanListReq.setAddRuleInfoId(reqDto.getAddRuleInfoId());//SimpleFieldAssign//sourceId:933697_1_41494
queryTimerTaskPlanListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933584_1_41494
    }
  
    /*3-2-09查重置下级检查项状态定时任务调度列表[3261]   */
    Assert.isNull(queryTimerTaskPlanListReq.getTaskDispatchTypeCode(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-任务调度类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getDispatchActionTypeCode(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-任务调度的行为类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getAddRuleInfoId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-生成辅助规则信息值不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getThemeContentId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-主题内容ID不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-是否执行完成不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getSpaceId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查重置下级检查项状态定时任务调度列表-创建于空间ID不能为空",false);
      listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((listOmsTargetTimingTaskDispatch!= null&&  listOmsTargetTimingTaskDispatch !=null && listOmsTargetTimingTaskDispatch.size()>0)) {
        //if(3-2-09查重置下级检查项状态定时任务调度列表.定时任务调度列表数据集条数 大于 0)  41495
        
//ModelCode: circulationCollections
        for (OmsTargetTimingTaskDispatch circulationCollectionsRes: listOmsTargetTimingTaskDispatch){ 
      
OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq.setIsArchive("FALSE");//sourceId:933618_1_41499
if(circulationCollectionsRes!=null){
      queryTargetObjDetailReq.setObjectiveId(circulationCollectionsRes.getObjectId());//SimpleFieldAssign//sourceId:933606_1_41499
    }
if(reqDto!=null){
      queryTargetObjDetailReq.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933652_1_41499
    }
  
    /*3-3-03查当前指标[2697]   */
    Assert.isNull(queryTargetObjDetailReq.getObjectiveId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-3-03查当前指标-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getEvaluationTemplateId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-3-03查当前指标-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getIsArchive(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-3-03查当前指标-是否存档不能为空",false);
      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((!(omsTargetObjective!= null&&  omsTargetObjective.getTargetValueType() !=null && omsTargetObjective.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")))) {
        //if(3-3-03查当前指标.冗余指标业务类型 不等于 主观定性)  41500
        
ImplementResetSubordinateManyCheckItemStateComRespDto implementResetSubordinateManyCheckItemStateComRespDto = null;
    if(omsTargetObjective !=null){
          ImplementResetSubordinateManyCheckItemStateComReqDto implementResetSubordinateManyCheckItemStateComReqDto=new ImplementResetSubordinateManyCheckItemStateComReqDto();
  implementResetSubordinateManyCheckItemStateComReqDto.setCustomField("UPDTAE_TARGET_VALUE");//CUSTOM_CONVENTION//sourceId:933661_1_41501
if(omsTargetObjective!=null){
      implementResetSubordinateManyCheckItemStateComReqDto.setTargetCycleContentId(omsTargetObjective.getObjectiveId());//SimpleFieldAssign//sourceId:958491_1_41501
implementResetSubordinateManyCheckItemStateComReqDto.setComCode(omsTargetObjective.getObjectiveCode());//SimpleFieldAssign//sourceId:933658_1_41501
    }
if(reqDto!=null){
      implementResetSubordinateManyCheckItemStateComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933659_1_41501
    }
  
    /*D3向下打开指标目标设置等检查项状态[5929]   */
    Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getCustomField(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-业务操作行为类型不能为空",false);
Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getTargetCycleContentId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-关联目标内容ID不能为空",false);
Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getComCode(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-通用编码标识不能为空",false);
Assert.isNull(implementResetSubordinateManyCheckItemStateComReqDto.getEvaluationTemplateId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3向下打开指标目标设置等检查项状态-冗余评价模板ID不能为空",false);
      implementResetSubordinateManyCheckItemStateComRespDto = offStateService.implementResetSubordinateManyCheckItemStateCom(implementResetSubordinateManyCheckItemStateComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq=new QueryTimerTaskPlanDetailReq();
  if(circulationCollectionsRes!=null){
      queryTimerTaskPlanDetailReq.setTimingTaskDispatchId(circulationCollectionsRes.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:933759_1_41510
    }
if(reqDto!=null){
      queryTimerTaskPlanDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933760_1_41510
    }
  
    /*3-2-09查定时任务调度（判断是否完成）[3187]   */
    Assert.isNull(queryTimerTaskPlanDetailReq.getTimingTaskDispatchId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查定时任务调度（判断是否完成）-定时任务调度记录ID不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09查定时任务调度（判断是否完成）-主题内容ID不能为空",false);
      omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((omsTargetTimingTaskDispatch!= null&&  omsTargetTimingTaskDispatch.getIsComplete() !=null && omsTargetTimingTaskDispatch.getIsComplete().equals("TRUE"))) {
        //if(3-2-09查定时任务调度（判断是否完成）.是否执行完成 等于 是)  41511
        
//processBranchName:继续循环 ,processBranchId:41512
        continue;
      }
AddUnifyMgtDeptOrderSetWeightOrTargetValueComRespDto addUnifyMgtDeptOrderSetWeightOrTargetValueComRespDto = null;
    if(omsTargetObjective !=null){
          AddUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto=new AddUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto();
  if(omsTargetObjective!=null){
      addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setObjectiveId(omsTargetObjective.getObjectiveId());//SimpleFieldAssign//sourceId:933662_1_41502
addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setObjectiveCode(omsTargetObjective.getObjectiveCode());//SimpleFieldAssign//sourceId:933663_1_41502
addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setTargetId(omsTargetObjective.getTargetId());//SimpleFieldAssign//sourceId:933667_1_41502
    }
if(reqDto!=null){
      addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:933664_1_41502
addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setBatchCode(reqDto.getBatchCode());//SimpleFieldAssign//sourceId:933666_1_41502
    }
if(circulationCollectionsRes!=null){
      addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.setContentId(circulationCollectionsRes.getStandbyField1());//SimpleFieldAssign//sourceId:933665_1_41502
    }
  
    /*D3新增统一管理部门命令-设权重或目标值(公共)[6359]   */
    Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getObjectiveId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-指标ID不能为空",false);
Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getObjectiveCode(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-指标标识不能为空",false);
Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getTargetId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-冗余目标ID不能为空",false);
Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getEvaluationTemplateId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto.getBatchCode(),"D3执行循环补偿改目标重置下级检查项状态(公共)-D3新增统一管理部门命令-设权重或目标值(公共)-统一管理批次批次标识不能为空",false);
      addUnifyMgtDeptOrderSetWeightOrTargetValueComRespDto = targetContentService.addUnifyMgtDeptOrderSetWeightOrTargetValueCom(addUnifyMgtDeptOrderSetWeightOrTargetValueComReqDto)/*vcase invoke isSameApp*/;
      
      
      
           }
boolean bOOLEAN ;
    OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch_2=new OmsTargetTimingTaskDispatch();
  omsTargetTimingTaskDispatch_2.setIsComplete("TRUE");//sourceId:933669_1_41513
omsTargetTimingTaskDispatch_2.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:933673_1_41513
omsTargetTimingTaskDispatch_2.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:933670_1_41513
if(circulationCollectionsRes!=null){
      omsTargetTimingTaskDispatch_2.setTimingTaskDispatchId(circulationCollectionsRes.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:933668_1_41513
    }
  
    /*3-2-09更新定时任务调度（已完成）[3186]   */
    Assert.isNull(omsTargetTimingTaskDispatch_2.getTimingTaskDispatchId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-定时任务调度记录ID不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch_2.getIsComplete(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-是否执行完成不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch_2.getOperationInductionId(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-操作人就职记录ID不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch_2.getOperateTime(),"D3执行循环补偿改目标重置下级检查项状态(公共)-3-2-09更新定时任务调度（已完成）-操作时间不能为空",false);
      bOOLEAN = mOmsTargetTimingTaskDispatchService.refreshTimerTaskPlan(omsTargetTimingTaskDispatch_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
      }
//ModelCode: circulationEnd
        }
      
      }
ImplementLoopOffsetUpdateTargetResetCheckItemStateComRespDto retData = new ImplementLoopOffsetUpdateTargetResetCheckItemStateComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3执行分析指标操作主体信息(公共)[6641]
   * gen by moon at 5/14/2023, 3:01:18 AM
   */
  @Trace(operationName = "D3执行分析指标操作主体信息(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyseObjtiveOpeBodyInfoComRespDto implementAnalyseObjtiveOpeBodyInfoCom(ImplementAnalyseObjtiveOpeBodyInfoComReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_3 =null;
if((reqDto!= null&& reqDto.getLevelNumber() != null &&reqDto!= null&& reqDto.getLevelNumber() == 1L)) {
        //if((D3执行分析指标操作主体信息(公共).层级 值不等于空  and D3执行分析指标操作主体信息(公共).层级 等于 1))  41554

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  receptionServiceReq.setAddRuleInfoTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:935503_1_41555
if(reqDto!=null){
      receptionServiceReq.setAddRuleInfoId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:935504_1_41555
    }

    /*M3约定：评价模板[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getAddRuleInfoTypeCode(),"D3执行分析指标操作主体信息(公共)-M3约定：评价模板-生成规则信息类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getAddRuleInfoId(),"D3执行分析指标操作主体信息(公共)-M3约定：评价模板-生成辅助规则信息值不能为空",false);
      receptionServiceRes = nbResetCheckItemState.implementAcceptField(receptionServiceReq);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setAddRuleInfoTypeCode(receptionServiceRes.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:935515_1_41556
receptionServiceReq_1.setAddRuleInfoId(receptionServiceRes.getAddRuleInfoId());//SimpleFieldAssign//sourceId:935516_1_41556
    }

    /*M3接收上文出参字段[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getAddRuleInfoTypeCode(),"D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成规则信息类型编码不能为空",false);
Assert.isNull(receptionServiceReq_1.getAddRuleInfoId(),"D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成辅助规则信息值不能为空",false);
      receptionServiceRes_2 = nbResetCheckItemState.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&& reqDto.getLevelNumber() != null &&reqDto!= null&& reqDto.getLevelNumber() > 1L)){
       //elseif((D3执行分析指标操作主体信息(公共).层级 值不等于空  and D3执行分析指标操作主体信息(公共).层级 大于 1))  41557

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  receptionServiceReq_2.setAddRuleInfoTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:935509_1_41558
if(reqDto!=null){
      receptionServiceReq_2.setAddRuleInfoId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:935510_1_41558
    }

    /*M3约定：被评对象目标周期[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getAddRuleInfoTypeCode(),"D3执行分析指标操作主体信息(公共)-M3约定：被评对象目标周期-生成规则信息类型编码不能为空",false);
Assert.isNull(receptionServiceReq_2.getAddRuleInfoId(),"D3执行分析指标操作主体信息(公共)-M3约定：被评对象目标周期-生成辅助规则信息值不能为空",false);
      receptionServiceRes_4 = nbResetCheckItemState.implementAcceptField(receptionServiceReq_2);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_3=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setAddRuleInfoTypeCode(receptionServiceRes_4.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:935515_1_41559
receptionServiceReq_3.setAddRuleInfoId(receptionServiceRes_4.getAddRuleInfoId());//SimpleFieldAssign//sourceId:935516_1_41559
    }

    /*M3接收上文出参字段[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getAddRuleInfoTypeCode(),"D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成规则信息类型编码不能为空",false);
Assert.isNull(receptionServiceReq_3.getAddRuleInfoId(),"D3执行分析指标操作主体信息(公共)-M3接收上文出参字段-生成辅助规则信息值不能为空",false);
      receptionServiceRes_6 = nbResetCheckItemState.implementAcceptField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
ImplementAnalyseObjtiveOpeBodyInfoComRespDto retData = new ImplementAnalyseObjtiveOpeBodyInfoComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setAddRuleInfoTypeCode(receptionServiceRes_3.getAddRuleInfoTypeCode());//SimpleFieldAssign//sourceId:935517_1
retData.setAddRuleInfoId(receptionServiceRes_3.getAddRuleInfoId());//SimpleFieldAssign//sourceId:935518_1
    }




return retData;
  }
/**
   * D3执行撤销批次处理状态检查项更新(公共)[7179]
   * gen by moon at 10/13/2023, 12:06:58 AM
   */
  @Trace(operationName = "D3执行撤销批次处理状态检查项更新(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUndoBatchHandleCheckItemStateComRespDto implementUndoBatchHandleCheckItemStateCom(ImplementUndoBatchHandleCheckItemStateComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getBatchSetObjectType() !=null && reqDto.getBatchSetObjectType().equals("TOP_EVA_TEMP_MGT"))) {
        //if(D3执行撤销批次处理状态检查项更新(公共).批次设置对象类型 等于 高层评价模板管理)  48400

     List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem =new ArrayList<>();
    QueryBizAppCheckItemStatListReq queryBizAppCheckItemStatListReq=new QueryBizAppCheckItemStatListReq();
  queryBizAppCheckItemStatListReq.setIsComplete("FALSE");//sourceId:1118168_1_48402
if(reqDto!=null){
      queryBizAppCheckItemStatListReq.setEntityId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1118167_1_48402
queryBizAppCheckItemStatListReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118172_1_48402
    }

    /*3-11-04查业务应用校验项状态列表[2768]   */
    Assert.isNull(queryBizAppCheckItemStatListReq.getEntityId(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-内容对象实例ID不能为空",false);
Assert.isNull(queryBizAppCheckItemStatListReq.getThemeContentId(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-主题内容ID不能为空",false);
Assert.isNull(queryBizAppCheckItemStatListReq.getIsComplete(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-是否已完成不能为空",false);
      listOmsBizAppStatusCheckItem = mOmsBizAppStatusCheckItemService.queryBizAppCheckItemStatList(queryBizAppCheckItemStatListReq)/*vcase invoke 本地 method 方法调用;*/;



     boolean bOOLEAN ;
    if(listOmsBizAppStatusCheckItem !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem)&& listOmsBizAppStatusCheckItem.size()>0 ){
          List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_2=new ArrayList<>();
  if(listOmsBizAppStatusCheckItem!= null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem)&&  listOmsBizAppStatusCheckItem !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem)){
      listOmsBizAppStatusCheckItem_2 = //objList-to-objLists
        listOmsBizAppStatusCheckItem.stream().map(item -> {
      OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
      elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48403
elm.setIsComplete("TRUE");//sourceId:218938_2_48403
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48403
    }

    /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

      bOOLEAN = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_2)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsTargetCategory> listOmsTargetCategory =new ArrayList<>();
    QueryTargetCatListReq queryTargetCatListReq=new QueryTargetCatListReq();
  queryTargetCatListReq.setIsArchive("FALSE");//sourceId:1118196_1_48404
if(reqDto!=null){
      queryTargetCatListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118195_1_48404
    }

    /*3-3-02查模板下目标分类列表[2592]   */
    Assert.isNull(queryTargetCatListReq.getEvaluationTemplateId(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-02查模板下目标分类列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatListReq.getIsArchive(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-02查模板下目标分类列表-是否存档不能为空",false);
      listOmsTargetCategory = mOmsTargetCategoryService.queryTargetCatList(queryTargetCatListReq)/*vcase invoke 本地 method 方法调用;*/;



List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_3 =new ArrayList<>();
    if(listOmsTargetCategory !=null&& !CollectionUtil.isEmpty(listOmsTargetCategory)&& listOmsTargetCategory.size()>0 ){
          BatchQueryBizAppCheckItemStatReq batchQueryBizAppCheckItemStatReq=new BatchQueryBizAppCheckItemStatReq();
  batchQueryBizAppCheckItemStatReq.setIsComplete("FALSE");//sourceId:1118202_1_48405
if(listOmsTargetCategory!= null&& !CollectionUtil.isEmpty(listOmsTargetCategory)&&  listOmsTargetCategory !=null&& !CollectionUtil.isEmpty(listOmsTargetCategory)){
      batchQueryBizAppCheckItemStatReq.setBizAppCheckItemStatList(listOmsTargetCategory.stream().map(item->item.getTargetCategoryId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1118198_1_48405
    }
if(reqDto!=null){
      batchQueryBizAppCheckItemStatReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118204_1_48405
    }

    /*3-11-04批量查业务应用校验项状态[2769]   */
    Assert.isNull(batchQueryBizAppCheckItemStatReq.getIsComplete(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-是否已完成不能为空",false);
Assert.isNull(batchQueryBizAppCheckItemStatReq.getThemeContentId(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-主题内容ID不能为空",false);
      listOmsBizAppStatusCheckItem_3 = mOmsBizAppStatusCheckItemService.batchQueryBizAppCheckItemStat(batchQueryBizAppCheckItemStatReq)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_1 ;
    if(listOmsBizAppStatusCheckItem_3 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_3)&& listOmsBizAppStatusCheckItem_3.size()>0 ){
          List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_5=new ArrayList<>();
  if(listOmsBizAppStatusCheckItem_3!= null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_3)&&  listOmsBizAppStatusCheckItem_3 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_3)){
      listOmsBizAppStatusCheckItem_5 = //objList-to-objLists
        listOmsBizAppStatusCheckItem_3.stream().map(item -> {
      OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
      elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48406
elm.setIsComplete("TRUE");//sourceId:218938_2_48406
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48406
    }

    /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

      bOOLEAN_1 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_5)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsTargetObjective> listOmsTargetObjective =new ArrayList<>();
    QueryTargetObjListReq queryTargetObjListReq=new QueryTargetObjListReq();
  queryTargetObjListReq.setLevelNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1118224_1_48407
queryTargetObjListReq.setIsArchive("FALSE");//sourceId:1118226_1_48407
if(reqDto!=null){
      queryTargetObjListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118225_1_48407
    }

    /*3-3-03查指标列表[2692]   */
    Assert.isNull(queryTargetObjListReq.getEvaluationTemplateId(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-03查指标列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjListReq.getLevelNumber(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-03查指标列表-层级不能为空",false);
Assert.isNull(queryTargetObjListReq.getIsArchive(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-03查指标列表-是否存档不能为空",false);
      listOmsTargetObjective = mOmsTargetObjectiveService.queryTargetObjList(queryTargetObjListReq)/*vcase invoke 本地 method 方法调用;*/;



List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_6 =new ArrayList<>();
    if(listOmsTargetObjective !=null&& !CollectionUtil.isEmpty(listOmsTargetObjective)&& listOmsTargetObjective.size()>0 ){
          BatchQueryBizAppCheckItemStatReq batchQueryBizAppCheckItemStatReq_1=new BatchQueryBizAppCheckItemStatReq();
  batchQueryBizAppCheckItemStatReq_1.setIsComplete("FALSE");//sourceId:1118202_1_48408
if(listOmsTargetObjective!= null&& !CollectionUtil.isEmpty(listOmsTargetObjective)&&  listOmsTargetObjective !=null&& !CollectionUtil.isEmpty(listOmsTargetObjective)){
      batchQueryBizAppCheckItemStatReq_1.setBizAppCheckItemStatList(listOmsTargetObjective.stream().map(item->item.getObjectiveId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1118198_1_48408
    }
if(reqDto!=null){
      batchQueryBizAppCheckItemStatReq_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118204_1_48408
    }

    /*3-11-04批量查业务应用校验项状态[2769]   */
    Assert.isNull(batchQueryBizAppCheckItemStatReq_1.getIsComplete(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-是否已完成不能为空",false);
Assert.isNull(batchQueryBizAppCheckItemStatReq_1.getThemeContentId(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-主题内容ID不能为空",false);
      listOmsBizAppStatusCheckItem_6 = mOmsBizAppStatusCheckItemService.batchQueryBizAppCheckItemStat(batchQueryBizAppCheckItemStatReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_2 ;
    if(listOmsBizAppStatusCheckItem_6 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_6)&& listOmsBizAppStatusCheckItem_6.size()>0 ){
          List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_7=new ArrayList<>();
  if(listOmsBizAppStatusCheckItem_6!= null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_6)&&  listOmsBizAppStatusCheckItem_6 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_6)){
      listOmsBizAppStatusCheckItem_7 = //objList-to-objLists
        listOmsBizAppStatusCheckItem_6.stream().map(item -> {
      OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
      elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48409
elm.setIsComplete("TRUE");//sourceId:218938_2_48409
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48409
    }

    /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

      bOOLEAN_2 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_7)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsTargetCategory> listOmsTargetCategory_2 =new ArrayList<>();
    QueryTargetCatListReq queryTargetCatListReq_1=new QueryTargetCatListReq();
  queryTargetCatListReq_1.setIsLast("TRUE");//sourceId:1171379_1_49960
queryTargetCatListReq_1.setIsArchive("FALSE");//sourceId:1171377_1_49960
if(reqDto!=null){
      queryTargetCatListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171376_1_49960
    }

    /*3-3-02查末级目标分类列表[2592]   */
    Assert.isNull(queryTargetCatListReq_1.getEvaluationTemplateId(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-02查末级目标分类列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatListReq_1.getIsLast(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-02查末级目标分类列表-目标分类是否末级不能为空",false);
Assert.isNull(queryTargetCatListReq_1.getIsArchive(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-02查末级目标分类列表-是否存档不能为空",false);
      listOmsTargetCategory_2 = mOmsTargetCategoryService.queryTargetCatList(queryTargetCatListReq_1)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: circulationCollections
        for (OmsTargetCategory circulationCollectionsRes: listOmsTargetCategory_2){

ImplementAmendSuperiorDashBoardComRespDto implementAmendSuperiorDashBoardComRespDto = null;
    ImplementAmendSuperiorDashBoardComReqDto implementAmendSuperiorDashBoardComReqDto=new ImplementAmendSuperiorDashBoardComReqDto();
  implementAmendSuperiorDashBoardComReqDto.setCheckItemCode("OBJECTIVE_STANDARD_SET_CHECK_ITEM");//CUSTOM_CONVENTION//sourceId:1171387_1_49959
implementAmendSuperiorDashBoardComReqDto.setCheckObjectTypeCode("OMS_TARGET_CATEGORY");//sourceId:1171390_1_49959
implementAmendSuperiorDashBoardComReqDto.setObjectTypeCode("OMS_TARGET_OBJECTIVE");//sourceId:1171394_1_49959
implementAmendSuperiorDashBoardComReqDto.setEmploySceneTypeCode("USED_TARGET_CONTNET_SET");//sourceId:1171393_1_49959
if(circulationCollectionsRes!=null){
      implementAmendSuperiorDashBoardComReqDto.setCheckObjectTypeId(circulationCollectionsRes.getTargetCategoryId());//SimpleFieldAssign//sourceId:1171388_1_49959
    }
if(reqDto!=null){
      implementAmendSuperiorDashBoardComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171391_1_49959
    }

    /*D3执行修正上级仪表盘(公共)[6500]   */
    Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getCheckItemCode(),"D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-检查项标识不能为空",false);
Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getCheckObjectTypeCode(),"D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-检查内容对象类型编码不能为空",false);
Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getCheckObjectTypeId(),"D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-检查内容对象ID 不能为空",false);
Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getObjectTypeCode(),"D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-内容对象类型编码不能为空",false);
Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getEmploySceneTypeCode(),"D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-使用场景编码不能为空",false);
Assert.isNull(implementAmendSuperiorDashBoardComReqDto.getThemeContentId(),"D3执行撤销批次处理状态检查项更新(公共)-D3执行修正上级仪表盘(公共)-主题内容ID不能为空",false);
      implementAmendSuperiorDashBoardComRespDto = offStateService.implementAmendSuperiorDashBoardCom(implementAmendSuperiorDashBoardComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: circulationEnd
        }

      }
else if((reqDto!= null&&  reqDto.getBatchSetObjectType() !=null && reqDto.getBatchSetObjectType().equals("BASIC_DIV_MGT")||reqDto!= null&&  reqDto.getBatchSetObjectType() !=null && reqDto.getBatchSetObjectType().equals("MID_DIV_MGT"))){
       //elseif((D3执行撤销批次处理状态检查项更新(公共).批次设置对象类型 等于 基层分工管理 or D3执行撤销批次处理状态检查项更新(公共).批次设置对象类型 等于 中层分工管理))  48401

List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_8 =new ArrayList<>();
    QueryBizAppCheckItemStatListReq queryBizAppCheckItemStatListReq_1=new QueryBizAppCheckItemStatListReq();
  queryBizAppCheckItemStatListReq_1.setIsComplete("FALSE");//sourceId:1118168_1_48410
if(reqDto!=null){
      queryBizAppCheckItemStatListReq_1.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1118167_1_48410
queryBizAppCheckItemStatListReq_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118172_1_48410
    }

    /*3-11-04查业务应用校验项状态列表[2768]   */
    Assert.isNull(queryBizAppCheckItemStatListReq_1.getEntityId(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-内容对象实例ID不能为空",false);
Assert.isNull(queryBizAppCheckItemStatListReq_1.getThemeContentId(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-主题内容ID不能为空",false);
Assert.isNull(queryBizAppCheckItemStatListReq_1.getIsComplete(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04查业务应用校验项状态列表-是否已完成不能为空",false);
      listOmsBizAppStatusCheckItem_8 = mOmsBizAppStatusCheckItemService.queryBizAppCheckItemStatList(queryBizAppCheckItemStatListReq_1)/*vcase invoke 本地 method 方法调用;*/;



boolean bOOLEAN_3 ;
    if(listOmsBizAppStatusCheckItem_8 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_8)&& listOmsBizAppStatusCheckItem_8.size()>0 ){
          List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_9=new ArrayList<>();
  if(listOmsBizAppStatusCheckItem_8!= null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_8)&&  listOmsBizAppStatusCheckItem_8 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_8)){
      listOmsBizAppStatusCheckItem_9 = //objList-to-objLists
        listOmsBizAppStatusCheckItem_8.stream().map(item -> {
      OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
      elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_48411
elm.setIsComplete("TRUE");//sourceId:218938_2_48411
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_48411
    }

    /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

      bOOLEAN_3 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_9)/*vcase invoke 本地 method 方法调用;*/;



           }
QueryDeptOrUcdTargetListComRespDto queryDeptOrUcdTargetListComRespDto = null;
    QueryDeptOrUcdTargetListComReqDto queryDeptOrUcdTargetListComReqDto=new QueryDeptOrUcdTargetListComReqDto();
  queryDeptOrUcdTargetListComReqDto.setCustomField("0");//CUSTOM_CONVENTION//sourceId:1118231_1_48412
if(reqDto!=null){
      queryDeptOrUcdTargetListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1118228_1_48412
queryDeptOrUcdTargetListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118230_1_48412
    }

    /*D3查询部门或UCD牵头目标列表(公共)[3938]   */
    Assert.isNull(queryDeptOrUcdTargetListComReqDto.getDeptId(),"D3执行撤销批次处理状态检查项更新(公共)-D3查询部门或UCD牵头目标列表(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptOrUcdTargetListComReqDto.getEvaluationTemplateId(),"D3执行撤销批次处理状态检查项更新(公共)-D3查询部门或UCD牵头目标列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryDeptOrUcdTargetListComReqDto.getCustomField(),"D3执行撤销批次处理状态检查项更新(公共)-D3查询部门或UCD牵头目标列表(公共)-自定义字段不能为空",false);
      queryDeptOrUcdTargetListComRespDto = indexSystemService.queryDeptOrUcdTargetListCom(queryDeptOrUcdTargetListComReqDto)/*vcase invoke isSameApp*/;



List<OmsTargetObjective> listOmsTargetObjective_2 =new ArrayList<>();
    if(queryDeptOrUcdTargetListComRespDto !=null){
          BatchQueryTargetObjListReq batchQueryTargetObjListReq=new BatchQueryTargetObjListReq();
  batchQueryTargetObjListReq.setIsArchive("FALSE");//sourceId:1171362_1_49954
if(queryDeptOrUcdTargetListComRespDto!=null){
      batchQueryTargetObjListReq.setTargetObjList(queryDeptOrUcdTargetListComRespDto.getDeptOrUserUcdTargetList());//list-field-assign//sourceId:1171360_1_49954
    }
if(reqDto!=null){
      batchQueryTargetObjListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171361_1_49954
    }

    /*3-3-03批量查指标列表[2203]   */
    Assert.isNull(batchQueryTargetObjListReq.getEvaluationTemplateId(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-03批量查指标列表-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetObjListReq.getIsArchive(),"D3执行撤销批次处理状态检查项更新(公共)-3-3-03批量查指标列表-是否存档不能为空",false);
      listOmsTargetObjective_2 = mOmsTargetObjectiveService.batchQueryTargetObjList(batchQueryTargetObjListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: circulationCollections
        for (OmsTargetObjective circulationCollectionsRes_2: listOmsTargetObjective_2){

QuerySubordinateMultiLevelIndicatorListComRespDto querySubordinateMultiLevelIndicatorListComRespDto = null;
    QuerySubordinateMultiLevelIndicatorListComReqDto querySubordinateMultiLevelIndicatorListComReqDto=new QuerySubordinateMultiLevelIndicatorListComReqDto();
  querySubordinateMultiLevelIndicatorListComReqDto.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1171339_1_49953
if(circulationCollectionsRes_2!=null){
      querySubordinateMultiLevelIndicatorListComReqDto.setObjectiveId(circulationCollectionsRes_2.getObjectiveId());//SimpleFieldAssign//sourceId:1171342_1_49953
querySubordinateMultiLevelIndicatorListComReqDto.setObjectiveCode(circulationCollectionsRes_2.getObjectiveCode());//SimpleFieldAssign//sourceId:1171340_1_49953
    }
if(reqDto!=null){
      querySubordinateMultiLevelIndicatorListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1171341_1_49953
    }

    /*D3查询下级多层级指标列表(公共)[5829]   */
    Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getObjectiveId(),"D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-指标ID不能为空",false);
Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getObjectiveCode(),"D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-指标标识不能为空",false);
Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getEvaluationTemplateId(),"D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(querySubordinateMultiLevelIndicatorListComReqDto.getComNumField(),"D3执行撤销批次处理状态检查项更新(公共)-D3查询下级多层级指标列表(公共)-通用数值字段（整数型）不能为空",false);
      querySubordinateMultiLevelIndicatorListComRespDto = targetContentService.querySubordinateMultiLevelIndicatorListCom(querySubordinateMultiLevelIndicatorListComReqDto)/*vcase invoke isSameApp*/;



List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_10 =new ArrayList<>();
    if(querySubordinateMultiLevelIndicatorListComRespDto !=null){
          BatchQueryBizAppCheckItemStatReq batchQueryBizAppCheckItemStatReq_2=new BatchQueryBizAppCheckItemStatReq();
  batchQueryBizAppCheckItemStatReq_2.setIsComplete("FALSE");//sourceId:1118202_1_49955
if(querySubordinateMultiLevelIndicatorListComRespDto!= null&&  querySubordinateMultiLevelIndicatorListComRespDto.getTargetObjByCodeList() !=null&& !CollectionUtil.isEmpty(querySubordinateMultiLevelIndicatorListComRespDto.getTargetObjByCodeList())){
      batchQueryBizAppCheckItemStatReq_2.setBizAppCheckItemStatList(querySubordinateMultiLevelIndicatorListComRespDto.getTargetObjByCodeList().stream().map(item->item.getObjectiveId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1118198_1_49955
    }
if(reqDto!=null){
      batchQueryBizAppCheckItemStatReq_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118204_1_49955
    }

    /*3-11-04批量查业务应用校验项状态[2769]   */
    Assert.isNull(batchQueryBizAppCheckItemStatReq_2.getIsComplete(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-是否已完成不能为空",false);
Assert.isNull(batchQueryBizAppCheckItemStatReq_2.getThemeContentId(),"D3执行撤销批次处理状态检查项更新(公共)-3-11-04批量查业务应用校验项状态-主题内容ID不能为空",false);
      listOmsBizAppStatusCheckItem_10 = mOmsBizAppStatusCheckItemService.batchQueryBizAppCheckItemStat(batchQueryBizAppCheckItemStatReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_4 ;
    if(listOmsBizAppStatusCheckItem_10 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_10)&& listOmsBizAppStatusCheckItem_10.size()>0 ){
          List<OmsBizAppStatusCheckItem> listOmsBizAppStatusCheckItem_11=new ArrayList<>();
  if(listOmsBizAppStatusCheckItem_10!= null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_10)&&  listOmsBizAppStatusCheckItem_10 !=null&& !CollectionUtil.isEmpty(listOmsBizAppStatusCheckItem_10)){
      listOmsBizAppStatusCheckItem_11 = //objList-to-objLists
        listOmsBizAppStatusCheckItem_10.stream().map(item -> {
      OmsBizAppStatusCheckItem elm = new OmsBizAppStatusCheckItem();
      elm.setStatusCheckItemId(item.getStatusCheckItemId());//SimpleFieldAssign//sourceId:218937_2_49956
elm.setIsComplete("TRUE");//sourceId:218938_2_49956
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030207_1_49956
    }

    /*3-11-04批量改业务应用校验项状态（恢复为已完成）[2770]   */

      bOOLEAN_4 = mOmsBizAppStatusCheckItemService.batchUpdateBizAppCheckItemStat(listOmsBizAppStatusCheckItem_11)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: circulationEnd
        }

    }
ImplementUndoBatchHandleCheckItemStateComRespDto retData = new ImplementUndoBatchHandleCheckItemStateComRespDto();





return retData;
  }
/**
   * D3执行检查项状态等撤销批次恢复(公共)[7178]
   * gen by moon at 8/31/2023, 12:09:15 PM
   */
  @Trace(operationName = "D3执行检查项状态等撤销批次恢复(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCheckItemStateEtcDeleteBatchRecoverComRespDto implementCheckItemStateEtcDeleteBatchRecoverCom(ImplementCheckItemStateEtcDeleteBatchRecoverComReqDto reqDto){


      //步骤0: M3执行接收字段入参（特殊方法） - implementAcceptField
     //ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setBatchSetObjectType(reqDto.getBatchSetObjectType());//SimpleFieldAssign//sourceId:1118275_1
receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1118256_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1118257_1
receptionServiceReq.setCustomField(reqDto.getAssumptionObjId());//SimpleFieldAssign//sourceId:1118258_1
receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1118249_1
receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1118248_1
receptionServiceReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1118247_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118246_1
      receptionServiceReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1077698_1
receptionServiceReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077699_1
    }

    /*M3接收字段入参[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBatchSetObjectType(),"D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-批次设置对象类型不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField(),"D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-自定义字段不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-冗余评价模板ID不能为空",false);
    Assert.isNull(receptionServiceReq.getObjectId(),"D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-归属对象内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getUseTypeCode(),"D3执行检查项状态等撤销批次恢复(公共)-M3接收字段入参-用途类型编码不能为空",false);
      receptionServiceRes = nbResetCheckItemState.implementAcceptField(receptionServiceReq);




//步骤1: D3执行撤销批次处理状态检查项更新(公共) - implementUndoBatchHandleCheckItemStateCom
     ImplementUndoBatchHandleCheckItemStateComRespDto implementUndoBatchHandleCheckItemStateComRespDto = null;
    ImplementUndoBatchHandleCheckItemStateComReqDto implementUndoBatchHandleCheckItemStateComReqDto=new ImplementUndoBatchHandleCheckItemStateComReqDto();
  if(reqDto!=null){
      implementUndoBatchHandleCheckItemStateComReqDto.setBatchSetObjectType(reqDto.getBatchSetObjectType());//SimpleFieldAssign//sourceId:1118274_1
implementUndoBatchHandleCheckItemStateComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1118235_1
implementUndoBatchHandleCheckItemStateComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1118236_1
implementUndoBatchHandleCheckItemStateComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1118237_1
implementUndoBatchHandleCheckItemStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118238_1
    }

    /*D3执行撤销批次处理状态检查项更新(公共)[7179]   */
    Assert.isNull(implementUndoBatchHandleCheckItemStateComReqDto.getBatchSetObjectType(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次处理状态检查项更新(公共)-批次设置对象类型不能为空",false);
Assert.isNull(implementUndoBatchHandleCheckItemStateComReqDto.getEvaluationTemplateId(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次处理状态检查项更新(公共)-冗余评价模板ID不能为空",false);
      implementUndoBatchHandleCheckItemStateComRespDto = implementUndoBatchHandleCheckItemStateCom(implementUndoBatchHandleCheckItemStateComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤2: D3执行统计更新执行进度(公共) - implementStatisticsUpdateExecuteProgressCom
     ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(Double.valueOf("10"));//CUSTOM_CONVENTION//sourceId:1077788_1
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1077789_1
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077790_1
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1077791_1
    }

    /*D3更新执行进度(10%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行检查项状态等撤销批次恢复(公共)-D3更新执行进度(10%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;




//步骤3: D3执行撤销批次高中基层刷新父子状态(公共) - implementUndoBatchTopMidBasicRefreshParentSonStateCom
     ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto implementUndoBatchTopMidBasicRefreshParentSonStateComRespDto = null;
    ImplementUndoBatchTopMidBasicRefreshParentSonStateComReqDto implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto=new ImplementUndoBatchTopMidBasicRefreshParentSonStateComReqDto();
  implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1118244_1
if(reqDto!=null){
      implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1118270_1
implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1118271_1
implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setAssumptionObjId(reqDto.getAssumptionObjId());//SimpleFieldAssign//sourceId:1118245_1
implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1118242_1
implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1118241_1
implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1118243_1
    }

    /*D3执行撤销批次高中基层刷新父子状态(公共)[7373]   */
    Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getEvaObjEntityId(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getEvaObjTypeCode(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getAssumptionObjId(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-内容节点归属对象ID不能为空",false);
Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getEvaluationTemplateId(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getObjectId(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getUseTypeCode(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-用途类型编码不能为空",false);
Assert.isNull(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto.getExecuteProgressValue(),"D3执行检查项状态等撤销批次恢复(公共)-D3执行撤销批次高中基层刷新父子状态(公共)-执行进度值不能为空",false);
      implementUndoBatchTopMidBasicRefreshParentSonStateComRespDto = implementUndoBatchTopMidBasicRefreshParentSonStateCom(implementUndoBatchTopMidBasicRefreshParentSonStateComReqDto)/*vcase invoke 同服务,同domain*/;




ImplementCheckItemStateEtcDeleteBatchRecoverComRespDto retData = new ImplementCheckItemStateEtcDeleteBatchRecoverComRespDto();





return retData;
  }
/**
   * D3执行撤销批次处理仪表盘分子分母(公共)[7180]
   * gen by moon at 7/7/2023, 4:48:06 PM
   */
  @Trace(operationName = "D3执行撤销批次处理仪表盘分子分母(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUndoBatchHandleDashBoardComRespDto implementUndoBatchHandleDashBoardCom(ImplementUndoBatchHandleDashBoardComReqDto reqDto){


      //virtualUsage 3-11-02查模板下检查仪表盘列表  45049
      List<OmsAssistCheckPanelUpdate> listOmsAssistCheckPanelUpdate =new ArrayList<>();
    QueryCheckItemPanelListReq queryCheckItemPanelListReq=new QueryCheckItemPanelListReq();
  queryCheckItemPanelListReq.setIsSpecialSign("FALSE");//sourceId:1030515_1_45049
if(reqDto!=null){
      queryCheckItemPanelListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030514_1_45049
    }

    /*3-11-02查模板下检查仪表盘列表[2717]   */
    Assert.isNull(queryCheckItemPanelListReq.getThemeContentId(),"D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02查模板下检查仪表盘列表-主题内容ID不能为空",false);
Assert.isNull(queryCheckItemPanelListReq.getIsSpecialSign(),"D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02查模板下检查仪表盘列表-是否特殊标记不能为空",false);
      listOmsAssistCheckPanelUpdate = mOmsAssistCheckPanelUpdateService.queryCheckItemPanelList(queryCheckItemPanelListReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D3计算数据集单条进度值(公共)  46976
      ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto = null;
    if(listOmsAssistCheckPanelUpdate !=null&& !CollectionUtil.isEmpty(listOmsAssistCheckPanelUpdate)&& listOmsAssistCheckPanelUpdate.size()>0 ){
          ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto=new ImplementCountDataSingleProgressComReqDto();
  if(listOmsAssistCheckPanelUpdate!= null&& !CollectionUtil.isEmpty(listOmsAssistCheckPanelUpdate)&&  listOmsAssistCheckPanelUpdate !=null&& !CollectionUtil.isEmpty(listOmsAssistCheckPanelUpdate)){
      implementCountDataSingleProgressComReqDto.setCountNumberDataSetsList(listOmsAssistCheckPanelUpdate.stream().map(item->item.getCheckItemPanelUpdateId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1077760_1_46976
    }
if(reqDto!=null){
      implementCountDataSingleProgressComReqDto.setCalcPara1(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1077762_1_46976
    }

    /*D3计算数据集单条进度值(公共)[6561]   */
    Assert.isNull(implementCountDataSingleProgressComReqDto.getCalcPara1(),"D3执行撤销批次处理仪表盘分子分母(公共)-D3计算数据集单条进度值(公共)-被除数值不能为空",false);
      implementCountDataSingleProgressComRespDto = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage M3-仪表盘发牌【循环开始】  45050
      //ModelCode: circulationCollections
        for (OmsAssistCheckPanelUpdate circulationCollectionsRes: listOmsAssistCheckPanelUpdate){

//virtualUsage D4-分母减分子  45052
      CalculateSubtractionOfTwoNumServiceComRespDto calculateSubtractionOfTwoNumServiceComRespDto = null;
    CalculateSubtractionOfTwoNumServiceComReqDto calculateSubtractionOfTwoNumServiceComReqDto=new CalculateSubtractionOfTwoNumServiceComReqDto();
  if(circulationCollectionsRes!=null){
      calculateSubtractionOfTwoNumServiceComReqDto.setCalcPara1(circulationCollectionsRes.getTargetValue()!=null?Double.valueOf(circulationCollectionsRes.getTargetValue()):null);//SimpleFieldAssign//sourceId:1030520_1_45052
calculateSubtractionOfTwoNumServiceComReqDto.setCalcPara2(circulationCollectionsRes.getActualValue()!=null?Double.valueOf(circulationCollectionsRes.getActualValue()):null);//SimpleFieldAssign//sourceId:1030521_1_45052
    }

    /*D4-分母减分子[3365]   */

      calculateSubtractionOfTwoNumServiceComRespDto = fwCalcCalculationRulesClient.calculateSubtractionOfTwoNumServiceCom(calculateSubtractionOfTwoNumServiceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((calculateSubtractionOfTwoNumServiceComRespDto!= null&& calculateSubtractionOfTwoNumServiceComRespDto.getCalcResult() > 0)) {
        //if(D4-分母减分子.计算结果 大于 0)  45053

boolean bOOLEAN ;
    OmsAssistCheckPanelUpdate omsAssistCheckPanelUpdate=new OmsAssistCheckPanelUpdate();
  if(circulationCollectionsRes!=null){
      omsAssistCheckPanelUpdate.setCheckItemPanelUpdateId(circulationCollectionsRes.getCheckItemPanelUpdateId());//SimpleFieldAssign//sourceId:1030506_1_45054
omsAssistCheckPanelUpdate.setActualValue(circulationCollectionsRes.getTargetValue());//SimpleFieldAssign//sourceId:1030507_1_45054
    }

    /*3-11-02修改检查仪表盘更新[320]   */
    Assert.isNull(omsAssistCheckPanelUpdate.getCheckItemPanelUpdateId(),"D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02修改检查仪表盘更新-检查仪表盘更新记录ID 不能为空",false);
Assert.isNull(omsAssistCheckPanelUpdate.getActualValue(),"D3执行撤销批次处理仪表盘分子分母(公共)-3-11-02修改检查仪表盘更新-实际数值不能为空",false);
      bOOLEAN = mOmsAssistCheckPanelUpdateService.updateAssistCheckPanelUpdate(omsAssistCheckPanelUpdate)/*vcase invoke 本地 method 方法调用;*/;



      }
//virtualUsage D3更新执行进度(计算单条进度值结果)  46977
      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    if(implementCountDataSingleProgressComRespDto !=null){
          ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
if(implementCountDataSingleProgressComRespDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1077713_1_46977
    }
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1077714_1_46977
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077715_1_46977
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1077716_1_46977
    }

    /*D3更新执行进度(计算单条进度值结果)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行撤销批次处理仪表盘分子分母(公共)-D3更新执行进度(计算单条进度值结果)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



      }
//virtualUsage M3-执行【循环结束】  45051
      //ModelCode: circulationEnd
        }

ImplementUndoBatchHandleDashBoardComRespDto retData = new ImplementUndoBatchHandleDashBoardComRespDto();





return retData;
  }
/**
   * D3执行撤销批次处理内容节点状态更新(公共)[7181]
   * gen by moon at 6/11/2023, 6:43:02 AM
   */
  @Trace(operationName = "D3执行撤销批次处理内容节点状态更新(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUndoBatchHandleParentSubStateStateComRespDto implementUndoBatchHandleParentSubStateStateCom(ImplementUndoBatchHandleParentSubStateStateComReqDto reqDto){


      //步骤0: 3-11-01查内容节点状态列表 - queryAssistNodeStatusList
     List<OmsAssistNodeStatus> listOmsAssistNodeStatus =new ArrayList<>();
    QueryAssistNodeStatusListReq queryAssistNodeStatusListReq=new QueryAssistNodeStatusListReq();
  queryAssistNodeStatusListReq.setCurrentLevelComplete("FALSE");//sourceId:1030309_1
if(reqDto!=null){
      queryAssistNodeStatusListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030306_1
    }

    /*3-11-01查批次下本级未完成的内容节点状态列表[318]   */
    Assert.isNull(queryAssistNodeStatusListReq.getThemeContentId(),"D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下本级未完成的内容节点状态列表-主题内容ID不能为空",false);
Assert.isNull(queryAssistNodeStatusListReq.getCurrentLevelComplete(),"D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下本级未完成的内容节点状态列表-是否本级完成不能为空",false);
      listOmsAssistNodeStatus = mOmsAssistNodeStatusService.queryAssistNodeStatusList(queryAssistNodeStatusListReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤1: 3-11-01批量改内容节点状态 - batchUpdateAssistNodeStatus
     boolean bOOLEAN ;
    if(listOmsAssistNodeStatus !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus)&& listOmsAssistNodeStatus.size()>0 ){
          List<OmsAssistNodeStatus> listOmsAssistNodeStatus_2=new ArrayList<>();
  if(listOmsAssistNodeStatus!= null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus)&&  listOmsAssistNodeStatus !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus)){
      listOmsAssistNodeStatus_2 = //objList-to-objLists
        listOmsAssistNodeStatus.stream().map(item -> {
      OmsAssistNodeStatus elm = new OmsAssistNodeStatus();
      elm.setAssistNodeStatusId(item.getAssistNodeStatusId());//SimpleFieldAssign//sourceId:218983_2
elm.setCurNodeDoneNum(item.getCurNodeNum());//SimpleFieldAssign//sourceId:218984_2
elm.setCurrentLevelComplete("TRUE");//sourceId:218985_2
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030311_1
    }

    /*3-11-01批量改内容节点状态本级已完成及本级完成数量[2774]   */

      bOOLEAN = mOmsAssistNodeStatusService.batchUpdateAssistNodeStatus(listOmsAssistNodeStatus_2)/*vcase invoke 本地 method 方法调用;*/;



           }

//步骤2: 3-11-01查内容节点状态列表 - queryAssistNodeStatusList
     List<OmsAssistNodeStatus> listOmsAssistNodeStatus_3 =new ArrayList<>();
    QueryAssistNodeStatusListReq queryAssistNodeStatusListReq_1=new QueryAssistNodeStatusListReq();
  queryAssistNodeStatusListReq_1.setNextLevelComplete("FALSE");//sourceId:1030312_1
if(reqDto!=null){
      queryAssistNodeStatusListReq_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030313_1
    }

    /*3-11-01查批次下下级未完成的内容节点状态列表[318]   */
    Assert.isNull(queryAssistNodeStatusListReq_1.getThemeContentId(),"D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下下级未完成的内容节点状态列表-主题内容ID不能为空",false);
Assert.isNull(queryAssistNodeStatusListReq_1.getNextLevelComplete(),"D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查批次下下级未完成的内容节点状态列表-是否下级完成不能为空",false);
      listOmsAssistNodeStatus_3 = mOmsAssistNodeStatusService.queryAssistNodeStatusList(queryAssistNodeStatusListReq_1)/*vcase invoke 本地 method 方法调用;*/;




//步骤3: 3-11-01批量改内容节点状态 - batchUpdateAssistNodeStatus
     boolean bOOLEAN_1 ;
    if(listOmsAssistNodeStatus_3 !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus_3)&& listOmsAssistNodeStatus_3.size()>0 ){
          List<OmsAssistNodeStatus> listOmsAssistNodeStatus_5=new ArrayList<>();
  if(listOmsAssistNodeStatus_3!= null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus_3)&&  listOmsAssistNodeStatus_3 !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus_3)){
      listOmsAssistNodeStatus_5 = //objList-to-objLists
        listOmsAssistNodeStatus_3.stream().map(item -> {
      OmsAssistNodeStatus elm = new OmsAssistNodeStatus();
      elm.setAssistNodeStatusId(item.getAssistNodeStatusId());//SimpleFieldAssign//sourceId:219081_2
elm.setCurNodeDoneNum(item.getNextNodeNum());//SimpleFieldAssign//sourceId:219082_2
elm.setNextLevelComplete("TRUE");//sourceId:219083_2
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030502_1
    }

    /*3-11-01批量改内容节点状态下级级已完成及下级完成数量[2774]   */

      bOOLEAN_1 = mOmsAssistNodeStatusService.batchUpdateAssistNodeStatus(listOmsAssistNodeStatus_5)/*vcase invoke 本地 method 方法调用;*/;



           }

//步骤4: 3-11-01查内容节点状态列表 - queryAssistNodeStatusList
     List<OmsAssistNodeStatus> listOmsAssistNodeStatus_6 =new ArrayList<>();
    QueryAssistNodeStatusListReq queryAssistNodeStatusListReq_2=new QueryAssistNodeStatusListReq();
  queryAssistNodeStatusListReq_2.setIsComplete("FALSE");//sourceId:1030503_1
if(reqDto!=null){
      queryAssistNodeStatusListReq_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1030504_1
    }

    /*3-11-01查当前批次下全部未完成的内容节点状态列表[318]   */
    Assert.isNull(queryAssistNodeStatusListReq_2.getThemeContentId(),"D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查当前批次下全部未完成的内容节点状态列表-主题内容ID不能为空",false);
Assert.isNull(queryAssistNodeStatusListReq_2.getIsComplete(),"D3执行撤销批次处理内容节点状态更新(公共)-3-11-01查当前批次下全部未完成的内容节点状态列表-是否已完成不能为空",false);
      listOmsAssistNodeStatus_6 = mOmsAssistNodeStatusService.queryAssistNodeStatusList(queryAssistNodeStatusListReq_2)/*vcase invoke 本地 method 方法调用;*/;




//步骤5: 3-11-01批量改内容节点状态 - batchUpdateAssistNodeStatus
     boolean bOOLEAN_2 ;
    if(listOmsAssistNodeStatus_6 !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus_6)&& listOmsAssistNodeStatus_6.size()>0 ){
          List<OmsAssistNodeStatus> listOmsAssistNodeStatus_8=new ArrayList<>();
  if(listOmsAssistNodeStatus_6!= null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus_6)&&  listOmsAssistNodeStatus_6 !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus_6)){
      listOmsAssistNodeStatus_8 = listOmsAssistNodeStatus_6.stream().map(item -> {
        OmsAssistNodeStatus elm =BeanUtil.toBean(item, OmsAssistNodeStatus.class);
        elm.setIsComplete("TRUE");

        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1030505_1
    }

    /*3-11-01批量改内容节点状态全部已完成[2774]   */

      bOOLEAN_2 = mOmsAssistNodeStatusService.batchUpdateAssistNodeStatus(listOmsAssistNodeStatus_8)/*vcase invoke 本地 method 方法调用;*/;



           }

ImplementUndoBatchHandleParentSubStateStateComRespDto retData = new ImplementUndoBatchHandleParentSubStateStateComRespDto();





return retData;
  }
/**
   * D3执行撤销批次高中基层刷新父子状态(公共)[7373]
   * gen by moon at 8/31/2023, 11:55:13 AM
   */
  @Trace(operationName = "D3执行撤销批次高中基层刷新父子状态(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto implementUndoBatchTopMidBasicRefreshParentSonStateCom(ImplementUndoBatchTopMidBasicRefreshParentSonStateComReqDto reqDto){


      //virtualUsage 3-11-01查父子状态内容范围  48392
      List<OmsAssistNodeStatus> listOmsAssistNodeStatus =new ArrayList<>();
    ImplementAssistNodeStatusByCodeOrderReq implementAssistNodeStatusByCodeOrderReq=new ImplementAssistNodeStatusByCodeOrderReq();
  implementAssistNodeStatusByCodeOrderReq.setEmploySceneTypeCode("USED_TARGET_CONTNET_SET");//sourceId:1117799_1_48392
implementAssistNodeStatusByCodeOrderReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1117801_1_48392
if(reqDto!=null){
      implementAssistNodeStatusByCodeOrderReq.setObjectId(reqDto.getAssumptionObjId());//SimpleFieldAssign//sourceId:1117798_1_48392
implementAssistNodeStatusByCodeOrderReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117800_1_48392
    }

    /*3-11-01查父子状态内容范围[6571]   */
    Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getObjectId(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-归属对象内容ID不能为空",false);
Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getThemeContentId(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-主题内容ID不能为空",false);
Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getEmploySceneTypeCode(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-使用场景编码不能为空",false);
Assert.isNull(implementAssistNodeStatusByCodeOrderReq.getSpaceId(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-11-01查父子状态内容范围-创建于空间ID不能为空",false);
      listOmsAssistNodeStatus = mOmsAssistNodeStatusService.implementAssistNodeStatusByCodeOrder(implementAssistNodeStatusByCodeOrderReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-09批量查内容目标父周期范围  48393
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    if(listOmsAssistNodeStatus !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus)&& listOmsAssistNodeStatus.size()>0 ){
          ImplementContentMatchTargetCycleCodeOrderReq implementContentMatchTargetCycleCodeOrderReq=new ImplementContentMatchTargetCycleCodeOrderReq();
  implementContentMatchTargetCycleCodeOrderReq.setIsParentCycle("TRUE");//sourceId:1117806_1_48393
implementContentMatchTargetCycleCodeOrderReq.setIsArchive("FALSE");//sourceId:1117809_1_48393
implementContentMatchTargetCycleCodeOrderReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1117810_1_48393
if(listOmsAssistNodeStatus!= null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus)&&  listOmsAssistNodeStatus !=null&& !CollectionUtil.isEmpty(listOmsAssistNodeStatus)){
      implementContentMatchTargetCycleCodeOrderReq.setEvaObjTargetCycleList(listOmsAssistNodeStatus.stream().map(item->item.getAssistNodeTypeObjectId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1117803_1_48393
    }
if(reqDto!=null){
      implementContentMatchTargetCycleCodeOrderReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1117804_1_48393
implementContentMatchTargetCycleCodeOrderReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1117805_1_48393
implementContentMatchTargetCycleCodeOrderReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117807_1_48393
    }

    /*3-3-09批量查内容目标父周期范围[6573]   */
    Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getEvaObjEntityId(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getEvaObjTypeCode(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-被评对象类型编码不能为空",false);
Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getIsParentCycle(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-是否父周期不能为空",false);
Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getEvaluationTemplateId(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-冗余评价模板ID不能为空",false);
Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getIsArchive(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-是否存档不能为空",false);
Assert.isNull(implementContentMatchTargetCycleCodeOrderReq.getSpaceId(),"D3执行撤销批次高中基层刷新父子状态(公共)-3-3-09批量查内容目标父周期范围-创建于空间ID不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.implementContentMatchTargetCycleCodeOrder(implementContentMatchTargetCycleCodeOrderReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage D3计算数据集单条进度值(公共)  48394
      ImplementCountDataSingleProgressComRespDto implementCountDataSingleProgressComRespDto = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          ImplementCountDataSingleProgressComReqDto implementCountDataSingleProgressComReqDto=new ImplementCountDataSingleProgressComReqDto();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      implementCountDataSingleProgressComReqDto.setCountNumberDataSetsList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1117769_1_48394
    }
if(reqDto!=null){
      implementCountDataSingleProgressComReqDto.setCalcPara1(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1117771_1_48394
    }

    /*D3计算数据集单条进度值(公共)[6561]   */
    Assert.isNull(implementCountDataSingleProgressComReqDto.getCalcPara1(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3计算数据集单条进度值(公共)-被除数值不能为空",false);
      implementCountDataSingleProgressComRespDto = progressPublicTechnicaCapacityService.implementCountDataSingleProgressCom(implementCountDataSingleProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage M3目标周期发牌【循环开始】  48395
      //ModelCode: circulationCollections
        for (OmsEvaluationObjectTargetCycle circulationCollectionsRes: listOmsEvaluationObjectTargetCycle){

//virtualUsage D3执行发单牌仪表盘父子状态(公共)  48398
      ImplementIssueSingleCardUpdateDashboardParentChildStatusComRespDto implementIssueSingleCardUpdateDashboardParentChildStatusComRespDto = null;
    ImplementIssueSingleCardUpdateDashboardParentChildStatusComReqDto implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto=new ImplementIssueSingleCardUpdateDashboardParentChildStatusComReqDto();
  implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEmploySceneTypeCode("USED_TARGET_CONTNET_SET");//sourceId:1117789_1_48398
if(circulationCollectionsRes!=null){
      implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1117780_1_48398
implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjTargetCycleCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1117781_1_48398
implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1117782_1_48398
implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaObjTypeCode(circulationCollectionsRes.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1117783_1_48398
implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1117784_1_48398
implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1117785_1_48398
implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:1117786_1_48398
implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setIsUseFirstDept(circulationCollectionsRes.getIsUseFirstDept());//SimpleFieldAssign//sourceId:1117788_1_48398
    }
if(reqDto!=null){
      implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117787_1_48398
    }

    /*D3执行发单牌仪表盘父子状态(公共)[5858]   */
    Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaObjTargetCycleCode(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaObjEntityId(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaObjTypeCode(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getTargetCycleContentTypeCode(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getTargetCycleContentId(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getTargetId(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEvaluationTemplateId(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto.getEmploySceneTypeCode(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行发单牌仪表盘父子状态(公共)-使用场景编码不能为空",false);
      implementIssueSingleCardUpdateDashboardParentChildStatusComRespDto = targetContentService.implementIssueSingleCardUpdateDashboardParentChildStatusCom(implementIssueSingleCardUpdateDashboardParentChildStatusComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3执行统计更新执行进度(公共)  48399
      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    if(implementCountDataSingleProgressComRespDto !=null){
          ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  if(implementCountDataSingleProgressComRespDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(implementCountDataSingleProgressComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1117772_1_48399
    }
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1117774_1_48399
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1117775_1_48399
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1117776_1_48399
    }

    /*D3执行统计更新执行进度(公共)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3执行撤销批次高中基层刷新父子状态(公共)-D3执行统计更新执行进度(公共)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage M3-执行【循环结束】  48396
      //ModelCode: circulationEnd
        }

ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto retData = new ImplementUndoBatchTopMidBasicRefreshParentSonStateComRespDto();





return retData;
  }
  //
}
